package com.jboltai.util.other;

import cn.hutool.core.util.StrUtil;

import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
import java.util.regex.Pattern;

public class StringUtil {
    /**
     * 将字符串转化成对应类型，<b>注意：<b/>,该方法只能用来转换基本类型及包装类、时间日期类型、BigDecimal 以及 BigInteger。
     * @param str
     * @param clazz
     * @param <T>
     * @return
     */
    public static <T> T convert(String str, Class<T> clazz) {
        if (clazz == String.class) {
            return (T) str;
        }

        if (StrUtil.isBlank(str)) {
            return (T) ParamType.getDefaultValue(clazz);
        }

        if (clazz == int.class || clazz == Integer.class) {
            return (T) Integer.valueOf(Double.valueOf(str).intValue());
        }
        if (clazz == double.class || clazz == Double.class) {
            return (T) Double.valueOf(str);
        }
        if (clazz == boolean.class || clazz == Boolean.class) {
            if (str.equals("true".intern()) || str.equals("on".intern()) || str.equals("1".intern())) {
                return (T) Boolean.TRUE;
            }
            return (T) Boolean.FALSE;
        }
        if (clazz == long.class || clazz == Long.class) {
            return (T) Long.valueOf(new BigDecimal(str).longValue());
        }
//        if (clazz == Date.class ) {
//            return (T) DateKit.parseDate(str);
//        }
//        if (clazz == java.sql.Date.class) {
//            Date date = DateKit.parseDate(str);
//            return date == null ? null : (T) new java.sql.Date(date.getTime());
//        }
//
//        if (clazz == Time.class) {
//            Date date = DateKit.parseDate(str);
//            return date == null ? null : (T) new Time(date.getTime());
//        }
        if (clazz == short.class || clazz == Short.class) {
            return (T) Short.valueOf(new BigDecimal(str).shortValue());
        }
        if (clazz == byte.class || clazz == Byte.class) {
            return (T) Byte.valueOf(new BigDecimal(str).byteValue());
        }
        if (clazz == float.class || clazz == Float.class) {
            return (T) Float.valueOf(new BigDecimal(str).floatValue());
        }
        if (clazz == char.class || clazz == Character.class) {
            return (T) new Character(str.charAt(0));
        }

        if (clazz.isEnum()) {
            try {
                Method getValueOf = clazz.getDeclaredMethod("valueOf", String.class);
                return (T) getValueOf.invoke(clazz, str);
            } catch (Exception e) {
                return null;
            }
        }


//        if (clazz == LocalDate.class) {
//            return (T) DateUtils.parseDate(str);
//        }
//        if (clazz == LocalTime.class) {
//            return (T) DateUtils.parseTime(str);
//        }
//
//        if (clazz == LocalDateTime.class) {
//            return (T) DateUtils.parseDateTime(str);
//        }

        if (clazz == BigInteger.class) {
            return (T) new BigInteger(str);
        }

        if (clazz == BigDecimal.class) {
            return (T) new BigDecimal(str);
        }
        throw new ClassCastException(str + "不支持直接转化为" + clazz.getSimpleName() + "类型数据");
    }

    /**
     * 正则表达式Pattern缓存
     */
    private static final ConcurrentHashMap<String, Pattern> PATTERN_CACHE = new ConcurrentHashMap<>();

    /**
     * 根据正则表达式提取字符串
     * @param str 源字符串
     * @param regex 正则表达式
     * @return 匹配到的第一个字符串，如果没有匹配到返回null
     */
    public static String extractByRegex(String str, String regex) {
        if (StrUtil.isBlank(str) || StrUtil.isBlank(regex)) {
            return null;
        }
        Pattern pattern = PATTERN_CACHE.computeIfAbsent(regex, r-> {
            return Pattern.compile(r, Pattern.DOTALL);
        });
        java.util.regex.Matcher matcher = pattern.matcher(str);
        if (matcher.find()) {
            return matcher.group();
        }
        return null;
    }
    /**
     * 根据正则表达式提取字符串
     * @param str 源字符串
     * @param regex 正则表达式
     * @return 匹配到的第一个字符串，如果没有匹配到返回null
     */
    public static String extractByRegex(String str, String regex, int group) {
        if (StrUtil.isBlank(str) || StrUtil.isBlank(regex)) {
            return null;
        }
        Pattern pattern = PATTERN_CACHE.computeIfAbsent(regex, r-> {
            return Pattern.compile(r, Pattern.DOTALL);
        });
        java.util.regex.Matcher matcher = pattern.matcher(str);
        if (matcher.find()) {
            return matcher.group(group);
        }
        return null;
    }

    public static List<String> extractAllByRegex(String content, String regex) {
        if (StrUtil.isBlank(content) || StrUtil.isBlank(regex)) {
            return new ArrayList<>();
        }
        Pattern pattern = PATTERN_CACHE.computeIfAbsent(regex, r -> {
            return Pattern.compile(r, Pattern.DOTALL);
        });
        java.util.regex.Matcher matcher = pattern.matcher(content);
        List<String> results = new ArrayList<>();
        while (matcher.find()) {
            results.add(matcher.group());
        }
        return results;
    }
}
